'use strict';
const tokenUtils = require('./tokenUtils');

/**
 * 认证中间件
 * 作为云函数的统一认证处理层
 */
class AuthMiddleware {
    /**
     * 获取用户信息
     * @param {Object} event 云函数事件对象
     * @param {Object} context 云函数上下文
     * @returns {Object} 用户信息
     */
    async getUserInfo(event, context) {
        // 首先尝试从event中获取token
        let token = event.token || event.uni_id_token;
        
        // 如果event中没有，则尝试从context中获取
        if (!token && context) {
            token = context.UNICLOUD_TOKEN || context.uni_id_token;
        }
        
        // 验证token
        if (token) {
            const verifyResult = tokenUtils.verifyToken(token);
            
            if (verifyResult.valid) {
                // token有效，返回用户信息
                const { payload } = verifyResult;
                const userId = payload.uid || payload.user_id;
                
                // 如果需要刷新token
                if (verifyResult.needRefresh) {
                    // 刷新token
                    const refreshResult = tokenUtils.refreshToken(token);
                    if (refreshResult.success) {
                        // 返回结果包含新token和用户信息
                        return {
                            isAuthenticated: true,
                            userId: userId,
                            token: refreshResult.token,
                            tokenRefreshed: true,
                            role: payload.role || 0,
                            payload
                        };
                    }
                }
                
                // 不需要刷新或刷新失败，返回原token
                return {
                    isAuthenticated: true,
                    userId: userId,
                    token: token,
                    tokenRefreshed: false,
                    role: payload.role || 0,
                    payload
                };
            } else {
                // token无效，尝试从event中获取用户ID
                return {
                    isAuthenticated: false,
                    error: verifyResult.message,
                    userId: event.userId || null,
                    token: null
                };
            }
        }
        
        // 如果没有token，检查event和context中是否有userId
        const userId = event.userId || (context && context.USERID) || null;
        
        return {
            isAuthenticated: false,
            error: 'Token不存在',
            userId: userId,
            token: null
        };
    }
    
    /**
     * 验证是否已登录
     * @param {Object} event 云函数事件对象
     * @param {Object} context 云函数上下文
     * @returns {Object} 验证结果 {authenticated, userInfo, code, message}
     */
    async authenticate(event, context) {
        const userInfo = await this.getUserInfo(event, context);
        
        if (userInfo.isAuthenticated) {
            return {
                authenticated: true,
                userInfo,
                code: 0,
                message: '用户已认证'
            };
        } else {
            // 尝试使用event中传递的userId作为备用身份
            if (userInfo.userId) {
                return {
                    authenticated: false,
                    userInfo,
                    code: 1,
                    message: '用户未认证，但提供了userId'
                };
            } else {
                return {
                    authenticated: false,
                    userInfo: null,
                    code: -1,
                    message: '用户未认证'
                };
            }
        }
    }
    
    /**
     * 获取数据库中的用户详细信息
     * @param {String} userId 用户ID
     * @returns {Object} 用户详细信息
     */
    async getUserDetailsFromDB(userId) {
        if (!userId) return null;
        
        try {
            const db = uniCloud.database();
            const result = await db.collection('users')
                .doc(userId)
                .field({ password: 0 }) // 排除密码
                .get();
                
            if (result.data && result.data.length > 0) {
                return result.data[0];
            } else if (result.data) {
                return result.data;
            }
            
            return null;
        } catch (error) {
            console.error('获取用户详情失败:', error);
            return null;
        }
    }
    
    /**
     * 处理认证失败的错误响应
     * @param {String} message 错误消息
     * @param {Number} code 错误代码
     * @returns {Object} 错误响应
     */
    handleAuthError(message = '认证失败', code = -2) {
        return {
            code,
            message
        };
    }
}

module.exports = new AuthMiddleware(); 